C++ Primer, Fifth Edition: Foundations of C++ Communication

In C++, communication is a flow, not a static storage event. The iostream library utilizes a polymorphic hierarchy where specialized classes like ifstream (files) and istringstream (memory) inherit from istream. This enables Stream Inheritance: functions designed for a base stream can transparently process data from any source.

The Non-Copyable Constraint

Streams represent unique, stateful connections to hardware. To prevent multiple objects from fighting over the same file pointer or console buffer, IO objects cannot be copied or assigned. Attempting code like ofstream out1, out2; out1 = out2; results in a compiler error. Consequently, IO objects must be passed by non-const reference.

The Sequential Bridge

While streams provide the interface, sequential containers (vector, list) provide the memory. Data streamed in is typically structured into these containers, choosing vector for speed or list for flexible insertions.

TERMINAL bash — 80x24

> Ready. Click "Run" to execute.

QUESTION 1

What causes the termination of while (cin >> i)?

The stream reaching a value of 0.

Encountering end-of-file (EOF) or an invalid input type.

The buffer becoming full.

A semicolon in the input stream.

QUESTION 2

Identify the error: ofstream out1, out2; out1 = out2;

Logic error: Files cannot have the same name.

Syntax error: Stream assignment is prohibited.

Runtime error: Buffer overflow.

No error; this is standard C++ usage.

QUESTION 3

How should an istream be passed to a function that reads from it?

By value (e.g., void func(istream is))

By const reference (e.g., void func(const istream &is))

By non-const reference (e.g., void func(istream &is))

As a pointer to a const object.

QUESTION 4

What is the primary flaw in this loop? while (iter1 < iter2) where iter is a list<int>::iterator?

Lists only support != comparison for iterators.

The loop will result in an infinite recursion.

List iterators must be decremented.

You cannot compare iterators of the same container.

✅ Correct!

Correct! Because lists are not stored contiguously, the < operator is not defined; use != instead.

❌ Incorrect

The < operator is only defined for random-access iterators (like vector or deque).

QUESTION 5

Why would you call is.clear() before returning an istream& from a function?

To delete all data within the stream.

To reset the error state (like EOF) so the caller can continue using it.

To flush the output buffer.

To close the associated file handle.

✅ Correct!

Once a stream hits EOF, it remains in an error state. clear() resets the state bits.

❌ Incorrect

clear() affects the state flags, not the data contents or file connection.

Case Study: The polymorphic Logging & Storage System

Managing Stream IO and Sequential Containers

You are designing a system that reads user input and stores it. You need a function that can read from either the standard console (cin) or a file, stores every word individually, and returns the stream to a healthy state for the next component.

1. Implement Exercise 8.1: Write the C++ function that reads an istream until EOF, prints the content, and resets the stream.

Solution:
The function would look like this:

istream& readAndReset(istream &is) {
    string val;
    while (is >> val) {
        cout << val << endl;
    }
    is.clear(); // Essential to reset EOF state
    return is;
}

2. Provide a usage guide for when to select: vector, list, deque, map, and set.

Solution:
vector: Best for fast random access and adding elements at the end. list: Best for frequent insertions/deletions anywhere in the container. deque: Best for insertions/deletions at both ends (queues). map: Best for key-value pairs where fast lookups by key are needed. set: Best for maintaining a sorted collection of unique elements.

3. Exercise 8.5: How would you modify a program to store each word of a file into a vector of strings?

Solution:
By using the extraction operator >>, which naturally stops at whitespace:

string word;
while (inputFile >> word) {
    vec.push_back(word);
}

This differs from getline(), which reads whole lines including spaces.